Python Argparse ॲडव्हान्स्ड: सबकमांड्स आणि कस्टम ॲक्शन क्लासेसमध्ये प्राविण्य मिळवणे

पायथनचे argparse मॉड्यूल कमांड-लाइन इंटरफेस (CLIs) तयार करण्यासाठी एक शक्तिशाली साधन आहे. जरी मूलभूत वापर तुलनेने सोपे असले तरी, argparse प्रगत वैशिष्ट्ये प्रदान करते जे अत्याधुनिक आणि वापरकर्ता-अनुकूल CLIs तयार करण्यास अनुमती देतात. ही ब्लॉग पोस्ट अशा दोन प्रगत वैशिष्ट्यांचा अभ्यास करते: सबकमांड्स आणि कस्टम ॲक्शन क्लासेस.

प्रगत Argparse का?

फक्त काही पर्यायांसह सोप्या स्क्रिप्ट्ससाठी, मूलभूत argparse कार्यक्षमता पुरेशी असू शकते. तथापि, आपल्या स्क्रिप्ट्सची जटिलता आणि कार्यक्षमता वाढत असताना, अधिक संरचित आणि सुव्यवस्थित CLI आवश्यक बनते. प्रगत argparse वैशिष्ट्ये मदत करतात:

• वापरकर्ता अनुभव सुधारा: वापरकर्त्यांसाठी स्पष्ट आणि अंतर्ज्ञानी इंटरफेस प्रदान करा.
• कोडची देखभालक्षमता वाढवा: आपला कोड तार्किक मॉड्यूल्समध्ये व्यवस्थित करा, ज्यामुळे तो समजणे आणि देखरेख करणे सोपे होईल.
• कार्यक्षमता वाढवा: एकाच स्क्रिप्टमध्ये जटिल वर्कफ्लो आणि अनेक ऑपरेशन्सना समर्थन द्या.
• पुनर्वापरक्षमतेला प्रोत्साहन द्या: पुनर्वापर करण्यायोग्य घटक तयार करा जे आपल्या ॲप्लिकेशनच्या विविध भागांमध्ये लागू केले जाऊ शकतात.

सबकमांड्स: जटिल CLIs व्यवस्थित करणे

सबकमांड्स ही संबंधित कमांड्सना एकाच मुख्य कमांडखाली एकत्र करण्याची एक पद्धत आहे. विविध प्रकारची विशिष्ट कार्ये करणाऱ्या ॲप्लिकेशन्ससाठी हे विशेषतः उपयुक्त आहे. उदाहरणार्थ, गिटचा विचार करा. ते सबकमांड्सचा मोठ्या प्रमाणावर वापर करते: git commit, git push, git pull, आणि असेच. प्रत्येक सबकमांडचा स्वतःचा आर्ग्युमेंट्स आणि पर्यायांचा संच असतो.

argparse सह सबकमांड्सची अंमलबजावणी

argparse सह सबकमांड्सची अंमलबजावणी करण्यासाठी, तुम्ही add_subparsers() पद्धत वापरता. येथे एक मूलभूत उदाहरण आहे:

            
import argparse

# Create the main parser
parser = argparse.ArgumentParser(description='A simple example with subcommands')

# Create the subparser
subparsers = parser.add_subparsers(dest='command', help='Available commands')

# Create the 'add' subcommand
add_parser = subparsers.add_parser('add', help='Add two numbers')
add_parser.add_argument('x', type=int, help='First number')
add_parser.add_argument('y', type=int, help='Second number')

# Create the 'subtract' subcommand
subtract_parser = subparsers.add_parser('subtract', help='Subtract two numbers')
subtract_parser.add_argument('x', type=int, help='First number')
subtract_parser.add_argument('y', type=int, help='Second number')

# Parse the arguments
args = parser.parse_args()

# Perform the action based on the subcommand
if args.command == 'add':
    result = args.x + args.y
    print(f'The sum is: {result}')
elif args.command == 'subtract':
    result = args.x - args.y
    print(f'The difference is: {result}')
else:
    parser.print_help()

            

              
                Copy
              
            
          

या उदाहरणात:

• आम्ही argparse.ArgumentParser() वापरून एक मुख्य पार्सर तयार करतो.
• आम्ही parser.add_subparsers(dest='command', help='Available commands') वापरून एक सबपार्सर जोडतो. The dest आर्ग्युमेंट निवडलेल्या सबकमांडचे नाव साठवणारे ॲट्रिब्यूट निर्दिष्ट करते.
• आम्ही 'add' आणि 'subtract' असे दोन सबकमांड subparsers.add_parser() वापरून तयार करतो.
• प्रत्येक सबकमांडचा स्वतःचा आर्ग्युमेंट्सचा संच (x आणि y) असतो.
• आम्ही parser.parse_args() वापरून आर्ग्युमेंट्स पार्स करतो.
• कोणता सबकमांड निवडला गेला हे निश्चित करण्यासाठी आम्ही args.command चे मूल्य तपासतो आणि नंतर संबंधित कृती करतो.

ही स्क्रिप्ट चालवण्यासाठी, तुम्ही खालील कमांड्स वापरू शकता:

python your_script.py add 5 3
python your_script.py subtract 10 2

प्रगत सबकमांड तंत्रे

1. सबकमांड्स हाताळण्यासाठी फंक्शन्स वापरणे

प्रत्येक सबकमांड हाताळण्यासाठी स्वतंत्र फंक्शन्स परिभाषित करणे हा अधिक संघटित दृष्टीकोन आहे. यामुळे कोडची वाचनीयता आणि देखभालक्षमता सुधारते.

            
import argparse

def add(args):
    result = args.x + args.y
    print(f'The sum is: {result}')

def subtract(args):
    result = args.x - args.y
    print(f'The difference is: {result}')

# Create the main parser
parser = argparse.ArgumentParser(description='A simple example with subcommands')

# Create the subparser
subparsers = parser.add_subparsers(dest='command', help='Available commands')

# Create the 'add' subcommand
add_parser = subparsers.add_parser('add', help='Add two numbers')
add_parser.add_argument('x', type=int, help='First number')
add_parser.add_argument('y', type=int, help='Second number')
add_parser.set_defaults(func=add)

# Create the 'subtract' subcommand
subtract_parser = subparsers.add_parser('subtract', help='Subtract two numbers')
subtract_parser.add_argument('x', type=int, help='First number')
subtract_parser.add_argument('y', type=int, help='Second number')
subtract_parser.set_defaults(func=subtract)

# Parse the arguments
args = parser.parse_args()

# Call the function associated with the subcommand
if hasattr(args, 'func'):
    args.func(args)
else:
    parser.print_help()

            

              
                Copy
              
            
          

येथे, आम्ही प्रत्येक सबकमांडसह एक फंक्शन जोडण्यासाठी set_defaults(func=...) वापरतो. त्यानंतर, पार्सिंगनंतर, जर फंक्शन अस्तित्वात असेल तर आम्ही ते योग्य फंक्शन कॉल करतो.

2. सबकमांड्सला एकत्र करणे (Nesting Subcommands)

तुम्ही अधिक जटिल आणि पदानुक्रमित CLIs तयार करण्यासाठी सबकमांड्सला एकत्र करू शकता. उदाहरणार्थ, क्लाउड संसाधने व्यवस्थापित करण्यासाठी एक CLI विचारात घ्या:

cloud compute instance create --name my-instance --region us-east-1
cloud storage bucket list --project my-project

या उदाहरणामध्ये, cloud ही मुख्य कमांड आहे, compute आणि storage ही सबकमांड्स आहेत, आणि instance आणि bucket ही सब-सबकमांड्स आहेत.

3. वास्तविक-जगातील उदाहरण: आंतरराष्ट्रीयीकरण साधन (Internationalization Tool)

अनेक भाषा असलेल्या ॲप्लिकेशनमध्ये भाषांतरे व्यवस्थापित करण्यासाठी एक साधनाची कल्पना करा. तुम्ही वेगवेगळ्या ऑपरेशन्सना व्यवस्थित करण्यासाठी सबकमांड्स वापरू शकता:

translation tool add-language --code fr_FR --name "French (France)"
translation tool extract-strings --source-dir src
translation tool translate --target-language es_ES --source-file strings.pot

हा दृष्टीकोन चिंतांचे स्पष्ट पृथक्करण करण्यास अनुमती देतो आणि साधन वापरण्यास आणि देखरेख करण्यास सोपे बनवतो, विशेषतः जेव्हा अनेक भाषा आणि विविध देशांमध्ये लागू होणाऱ्या भाषांतर वर्कफ्लोशी व्यवहार करताना.

कस्टम ॲक्शन क्लासेस: आर्ग्युमेंट पार्सिंगला अनुकूल करणे

argparse तुम्हाला आर्ग्युमेंट्स कसे प्रक्रिया केले जातात हे सानुकूलित करण्यासाठी कस्टम ॲक्शन क्लासेस परिभाषित करण्याची अनुमती देते. डीफॉल्ट आर्ग्युमेंट प्रक्रिया वर्तन पुरेसे नसलेल्या परिस्थितींसाठी हे उपयुक्त आहे. ॲक्शन क्लास हा argparse.Action मधून वारसा घेणारा आणि __call__ पद्धतीला ओव्हरराइड करणारा क्लास आहे.

कस्टम ॲक्शन क्लास तयार करणे

येथे एक कस्टम ॲक्शन क्लासचे उदाहरण आहे जे आर्ग्युमेंटला अपरकेसमध्ये रूपांतरित करते:

            
import argparse

class ToUpper(argparse.Action):
    def __call__(self, parser, namespace, values, option_string=None):
        if isinstance(values, list):
            setattr(namespace, self.dest, [v.upper() for v in values])
        else:
            setattr(namespace, self.dest, values.upper())

# Create the parser
parser = argparse.ArgumentParser(description='Example with custom action')

# Add an argument with the custom action
parser.add_argument('--name', action=ToUpper, help='Name to convert to uppercase')
parser.add_argument('--cities', action=ToUpper, nargs='+', help='List of cities to convert to uppercase')

# Parse the arguments
args = parser.parse_args()

# Print the result
if args.name:
    print(f'Name: {args.name}')
if args.cities:
    print(f'Cities: {args.cities}')

            

              
                Copy
              
            
          

या उदाहरणात:

• आम्ही ToUpper नावाचा एक क्लास परिभाषित करतो जो argparse.Action मधून वारसा घेतो.
• आर्ग्युमेंट आढळल्यावर __call__ पद्धत कॉल केली जाते. ती खालील आर्ग्युमेंट्स घेते:
  • parser: The ArgumentParser ऑब्जेक्ट.
  • namespace: पार्स केलेले आर्ग्युमेंट्स साठवले जातात ते नेमस्पेस ऑब्जेक्ट.
  • values: आर्ग्युमेंटचे मूल्ये.
  • option_string: ही कृती बोलावण्यासाठी वापरलेली ऑप्शन स्ट्रिंग (उदा. --name).
• __call__ पद्धतीच्या आत, आम्ही values.upper() वापरून मूल्याला अपरकेसमध्ये रूपांतरित करतो आणि setattr(namespace, self.dest, values.upper()) वापरून नेमस्पेसमध्ये साठवतो.
• आम्ही parser.add_argument('--name', action=ToUpper, help='Name to convert to uppercase') वापरून पार्सरमध्ये एक आर्ग्युमेंट जोडतो. आम्ही action आर्ग्युमेंटला आमचा कस्टम ॲक्शन क्लास म्हणून निर्दिष्ट करतो.

ही स्क्रिप्ट चालवण्यासाठी, तुम्ही खालील कमांड्स वापरू शकता:

python your_script.py --name john
python your_script.py --cities london paris tokyo

कस्टम ॲक्शन क्लासेससाठी वापर प्रकरणे

1. इनपुट प्रमाणित करणे

तुम्ही इनपुट प्रमाणित करण्यासाठी आणि जर इनपुट अवैध असेल तर त्रुटी निर्माण करण्यासाठी कस्टम ॲक्शन क्लासेस वापरू शकता. उदाहरणार्थ, तुम्ही एक ॲक्शन क्लास तयार करू शकता जो फाइल अस्तित्वात आहे की नाही किंवा संख्या विशिष्ट श्रेणीत आहे की नाही हे तपासतो.

            
import argparse
import os

class FileMustExist(argparse.Action):
    def __call__(self, parser, namespace, values, option_string=None):
        if not os.path.exists(values):
            raise argparse.ArgumentTypeError(f'File not found: {values}')
        setattr(namespace, self.dest, values)

parser = argparse.ArgumentParser(description='Example validating file existence.')
parser.add_argument('--input-file', action=FileMustExist, help='Path to input file.')

args = parser.parse_args()

print(f'Input file: {args.input_file}')

            

              
                Copy
              
            
          

2. युनिट्स रूपांतरित करणे

तुम्ही युनिट्स रूपांतरित करण्यासाठी कस्टम ॲक्शन क्लासेस वापरू शकता. उदाहरणार्थ, तुम्ही एक ॲक्शन क्लास तयार करू शकता जो तापमान सेल्सिअसवरून फॅरेनहाइटमध्ये रूपांतरित करतो.

3. जटिल डेटा स्ट्रक्चर्स हाताळणे

जर तुम्हाला आर्ग्युमेंट्सला जटिल डेटा स्ट्रक्चर्समध्ये (उदा. डिक्शनरी, ऑब्जेक्ट्सची यादी) पार्स करण्याची आवश्यकता असेल, तर तुम्ही पार्सिंग लॉजिक हाताळण्यासाठी कस्टम ॲक्शन क्लासेस वापरू शकता.

4. उदाहरण: टाइम झोन्स हाताळणे

वेगवेगळ्या टाइम झोन्समध्ये तारखा आणि वेळा हाताळण्याची आवश्यकता असलेल्या ॲप्लिकेशनचा विचार करा. pytz सारख्या लायब्ररी वापरून डेट स्ट्रिंग पार्स करण्यासाठी आणि विशिष्ट टाइम झोनमध्ये रूपांतरित करण्यासाठी कस्टम ॲक्शन क्लास वापरला जाऊ शकतो.

            
import argparse
import datetime
import pytz

class TimeZoneConverter(argparse.Action):
    def __init__(self, option_strings, dest, timezone=None, **kwargs):
        super().__init__(option_strings, dest, **kwargs)
        self.timezone = timezone

    def __call__(self, parser, namespace, values, option_string=None):
        try:
            dt = datetime.datetime.fromisoformat(values)
            if self.timezone:
                tz = pytz.timezone(self.timezone)
                dt = tz.localize(dt)
            setattr(namespace, self.dest, dt)
        except ValueError:
            raise argparse.ArgumentTypeError(f"Invalid date/time format.  Use ISO format (YYYY-MM-DDTHH:MM:SS): {values}")
        except pytz.exceptions.UnknownTimeZoneError:
            raise argparse.ArgumentTypeError(f"Invalid Timezone: {self.timezone}")

parser = argparse.ArgumentParser(description='Example with timezone conversion.')
parser.add_argument('--event-time', action=TimeZoneConverter, timezone='America/Los_Angeles', help='Event time in ISO format (YYYY-MM-DDTHH:MM:SS). Converts to America/Los_Angeles timezone.')

args = parser.parse_args(['--event-time', '2024-10-27T10:00:00'])

print(f'Event Time (Los Angeles): {args.event_time}')

            

              
                Copy
              
            
          

हे उदाहरण दर्शवते की कस्टम ॲक्शन्स pytz लायब्ररी वापरून टाइम झोन रूपांतरणे कशी हाताळू शकतात, एक अधिक अत्याधुनिक वापर प्रदर्शित करतात जो जागतिक स्तरावर संबंधित आहे.

प्रगत Argparse वापरण्यासाठी सर्वोत्तम पद्धती

• सोपे ठेवा: तुमचा CLI जास्त गुंतागुंतीचा करू नका. आवश्यक असेल तेव्हाच सबकमांड्स आणि कस्टम ॲक्शन्स वापरा.
• स्पष्ट मदत संदेश द्या: प्रत्येक कमांड आणि आर्ग्युमेंटसाठी स्पष्ट आणि संक्षिप्त मदत संदेश लिहा. add_argument() मधील help आर्ग्युमेंटचा मोठ्या प्रमाणावर वापर करा.
• इनपुट प्रमाणित करा: त्रुटी आणि सुरक्षा भेद्यता टाळण्यासाठी नेहमी वापरकर्त्याचे इनपुट प्रमाणित करा.
• सुसंगत नामकरण पद्धती वापरा: कमांड्स, आर्ग्युमेंट्स आणि पर्यायांसाठी सुसंगत नामकरण पद्धतींचे पालन करा. लांब ऑप्शन नावासाठी kebab-case (--my-option) वापरण्याचा विचार करा.
• चाचणी पूर्णपणे करा: वेगवेगळ्या इनपुट आणि परिस्थितींसह तुमच्या CLI ची पूर्णपणे चाचणी करा.
• तुमच्या CLI चे दस्तऐवजीकरण करा: तुमच्या CLI साठी सर्वसमावेशक दस्तऐवजीकरण प्रदान करा, ज्यामध्ये प्रत्येक कमांड आणि आर्ग्युमेंट कसे वापरावे याची उदाहरणे समाविष्ट आहेत. स्फिंक्स (Sphinx) सारखी साधने तुमच्या कोडमधून दस्तऐवजीकरण तयार करू शकतात.
• स्थानिकीकरणाचा विचार करा: जर तुमचा CLI जागतिक प्रेक्षकांसाठी असेल, तर तुमच्या मदत संदेशांचे आणि इतर वापरकर्ता-दर्शनी मजकुराचे स्थानिकीकरण करण्याचा विचार करा.

निष्कर्ष

सबकमांड्स आणि कस्टम ॲक्शन क्लासेस हे argparse सह अत्याधुनिक आणि वापरकर्ता-अनुकूल CLIs तयार करण्यासाठी शक्तिशाली साधने आहेत. या प्रगत वैशिष्ट्यांमध्ये प्राविण्य मिळवून, तुम्ही विविध वापरकर्ता वर्गाच्या गरजा पूर्ण करणारे मजबूत, देखरेख करण्यायोग्य आणि स्केलेबल कमांड-लाइन ॲप्लिकेशन्स तयार करू शकता. अनेक भाषांच्या ॲप्लिकेशन्स व्यवस्थापित करण्यापासून ते जगभरातील टाइम झोन्स हाताळण्यापर्यंत, शक्यता खूप मोठ्या आहेत. तुमच्या पायथन स्क्रिप्टिंग आणि कमांड-लाइन टूल डेव्हलपमेंटला पुढील स्तरावर नेण्यासाठी या तंत्रांचा स्वीकार करा.